home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / hotjava3 / hotjava3.exe / hotjava / classsrc / java / lang / Double.java < prev    next >
Encoding:
Java Source  |  1995-08-11  |  4.3 KB  |  171 lines
  1. /*
  2.  * @(#)Double.java    1.17 95/05/18  
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.lang;
  21.  
  22. /**
  23.  * The Double class is a wrapper for double values.
  24.  * @version     1.17, 18 May 1995
  25.  * @author    Lee Boynton
  26.  * @author    Arthur van Hoff
  27.  */
  28.  
  29. public final
  30. class Double extends Number {
  31.     /**
  32.      * Positive inifinity.
  33.      */
  34.     public static final double POSITIVE_INFINITY = 1.0d / 0.0;
  35.  
  36.     /**
  37.      * Negative inifinity.
  38.      */
  39.     public static final double NEGATIVE_INFINITY = -1.0d / 0.0;
  40.  
  41.     /* REMIND: comment this in once the nightly can compile NANs
  42.      * Not-a-Number. <em>Note: is not equal to anything, including
  43.      * itself</em>
  44.     public static final double NAN = 0.0d / 0.0;
  45.      */
  46.  
  47.     /**
  48.      * The maximum value a double can have.
  49.      */
  50.     public static final double MAX_VALUE = 1.79769313486231570e+308;
  51.  
  52.     /**
  53.      * The minimum value a double can have.
  54.      */
  55.     public static final double MIN_VALUE = 4.94065645841246544e-324;
  56.  
  57.     /**
  58.      * Returns true if the argument is the special Not-a-Number (NaN) value.
  59.      * @param v    the value to be tested
  60.      * @return    true if the value is NaN
  61.      */
  62.     static public boolean isNan(double v) {
  63.     return (v != v);
  64.     }
  65.  
  66.     /**
  67.      * Returns true if the number is infinitely large in magnitude.
  68.      * @param v    the value to be tested
  69.      * @return    true if the value is infinitely large in magnitude
  70.      */
  71.     static public boolean isInfinite(double v) {
  72.     return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
  73.     }
  74.  
  75.     /**
  76.      * The value of the float.
  77.      */
  78.     private double value;
  79.  
  80.     /**
  81.      * Constructs a wrapper for the given double value.
  82.      * @param value the value of the Double
  83.      */
  84.     public Double(double value) {
  85.     this.value = value;
  86.     }
  87.  
  88.     /**
  89.      * Returns true if this double value is Not-a-Number (NaN).
  90.      */
  91.     public boolean isNan() {
  92.     return isNan(value);
  93.     }
  94.  
  95.     /**
  96.      * Returns true if this double value is infinitely large in magnitude.
  97.      */
  98.     public boolean isInfinite() {
  99.     return isInfinite(value);
  100.     }
  101.  
  102.     /**
  103.      * Returns a string representation of this Double object.
  104.      */
  105.     public String toString() {
  106.     return String.valueOf(value);
  107.     }
  108.  
  109.     /**
  110.      * Returns the integer value of this double (by casting to an int).
  111.      */
  112.     public int intValue() {
  113.     return (int)value;
  114.     }
  115.  
  116.     /**
  117.      * Returns the long value of this double (by casting to a long).
  118.      */
  119.     public long longValue() {
  120.     return (long)value;
  121.     }
  122.  
  123.     /**
  124.      * Returns the float value.
  125.      */
  126.     public float floatValue() {
  127.     return (float)value;
  128.     }
  129.  
  130.     /**
  131.      * Returns the double value.
  132.      */
  133.     public double doubleValue() {
  134.     return (double)value;
  135.     }
  136.  
  137.     /**
  138.      * Returns a hashcode for this double.
  139.      */
  140.     public int hashCode() {
  141.     return (int)value;
  142.     }
  143.  
  144.     /**
  145.      * Compares this object against some other object.
  146.      *
  147.      * <em>Note: To be useful in hashtables this method
  148.      * considers two Nan double values to be equal. This
  149.      * is not according to IEEE specification</em>
  150.      *
  151.      * @param obj        the object to compare with
  152.      * @return         true if the object is the same
  153.      */
  154.     public boolean equals(Object obj) {
  155.     if ((obj != null) && (obj instanceof Double)) {
  156.         if ((value == ((Double)obj).value) || (isNan(value) && isNan(((Double)obj).value))) {
  157.         return true;
  158.         }
  159.     }
  160.     return false;
  161.     }
  162.  
  163.     /**
  164.      * Returns the double that the string represents.
  165.      * @param s        the string to be parsed
  166.      * @return         the value of the string
  167.      * @exception NumberFormatException The string cannot be parsed.
  168.      */
  169.     public static native Double valueOf(String s);
  170. }
  171.